import { cloneDeep } from 'lodash';

// 根据右侧的选中arr2状态删除取消左侧的选中arr1
export function deleteStringsFromArray(arr1, arr2) {
  return arr1.filter((str) => !arr2.includes(str));
}
/**
 * 设置受控选中和禁用状态用 - 修改选中，禁用状态
 * @param treeData 树形数据
 * @param strings 字符串数组（情景id）
 * @param hasDisabled 是否设置选中的 disabled，点击穿梭到右边用
 * @returns {*}
 */
export function transCheckedAndDisabled(treeData, strings, hasDisabled = false) {
  function traverseTree(data) {
    data.forEach((item) => {
      if (item.children && item.children.length > 0) {
        traverseTree(item.children); // 递归遍历子项
      } else {
        // 一样则设置checked: true否则false
        if (strings.includes(item.id)) {
          // 匹配到了没设置hasDisabled为true 设置为原来地disabled值有的话就用没有就是false
          if (!hasDisabled) {
            item.disabled = item.disabled ? item.disabled : false;
          } else {
            // 匹配到了设置了hasDisabled为true 设置为disabled为true
            item.disabled = true;
          }
          item.checked = true;
        } else {
          // 没匹配到 有disabled用原来地， 没有就false
          item.disabled = item.disabled ? item.disabled : false;
          item.checked = false;
        }
      }
    });
  }
  const newTreeData = cloneDeep(treeData);
  traverseTree(newTreeData);
  return newTreeData;
}

/** 左边用
 * 遍历sceneTree和sceneToRisk，sceneTree内插入sceneToRisk的riskFactor（因子）
 * @param config1 sceneTree
 * @param config2 sceneToRisk
 * @returns {*}
 */
export function insertRiskFactor(config1, config2) {
  config1.forEach((element) => {
    if (element.children) {
      // 递归调用函数处理子元素
      insertRiskFactor(element.children, config2);
    }
    const match = config2.find((item) => item.sceneId === element.id);
    if (match) {
      element.riskFactor = match.riskFactor;
    }
  });
  // 返回处理后的config1
  return config1;
}
/** 通过左侧选中的id筛选右侧渲染列表的结构
 * 返回满足filters的节点，并且保持data结构的顺序，以及filters的顺序
 * @param data
 * @param filters
 * @returns {*}
 */
export function filterAndSortTreeData(data, filters) {
  const result = [];
  for (const item of data) {
    const filteredItem = { ...item };
    if (filteredItem.children && filteredItem.children?.length > 0) {
      filteredItem.children = filterAndSortTreeData(filteredItem.children, filters);
    }
    if (filters.includes(item.id) || filteredItem.children?.length > 0) {
      result.push(filteredItem);
    }
  }
  result.sort((a, b) => {
    const aIndex = filters.indexOf(a.id);
    const bIndex = filters.indexOf(b.id);
    return aIndex - bIndex;
  });
  return result;
}
/** 通过左侧选中的id筛选右侧渲染列表的结构
 * 返回满足strings的节点，保持arr结构
 * ----------------------不满足排序需求！！！！！！！！废弃  改用filterAndSortTreeData
 * @param arr
 * @param strings
 * @returns {*}
 */
export function findMatchingObjects(arr, strings) {
  return arr.filter((obj) => {
    if (strings.includes(obj.id)) {
      return true; // 当前对象满足条件，保留它
    }
    if (obj.children && obj.children.length > 0) {
      obj.children = findMatchingObjects(obj.children, strings);
      return obj.children.length > 0; // 当前对象的子对象满足条件，保留它
    }
    return false; // 当前对象以及其子对象都不满足条件，删除它
  });
}
// 递归删除children为空的项
function removeEmptyChildren(arr) {
  for (let i = arr.length - 1; i >= 0; i--) {
    const obj = arr[i];
    if (obj.children && obj.children.length > 0) {
      removeEmptyChildren(obj.children);
    }
    if (obj.children && obj.children.length === 0) {
      arr.splice(i, 1);
    }
  }
}
// 根据strings来筛选arrParams存在的
export function filterExistItem(arrParams, strings) {
  const arr = cloneDeep(arrParams);
  const res = [];
  for (let i = 0; i < arr.length; i++) {
    const obj = arr[i];
    const { children } = obj;
    if (children) {
      obj.children = filterExistItem(children, strings);
    }
    if (!strings.includes(obj.id)) {
      res.push(obj);
    }
  }
  removeEmptyChildren(res);
  return res;
}
// 根据右侧选择的节点sceneIdListRight 找到左侧的渲染数据放开禁用
export function checkedAndDisabledRollback(treeData, strings) {
  function traverseTree(data) {
    data.forEach((item) => {
      if (item.children && item.children.length > 0) {
        traverseTree(item.children); // 递归遍历子项
      } else {
        // 一样则设置checked: true否则false
        if (strings.includes(item.id)) {
          item.disabled = false;
          item.checked = false;
        }
      }
    });
  }
  const newTreeData = cloneDeep(treeData);
  traverseTree(newTreeData);
  return newTreeData;
}

/**
 * 递归上移下移
 * @param prevData 树形数据
 * @param id 根据id移动
 * @param moveType 移动类型， 上移up，下移down
 * @returns {*}
 */
export const sortInfo = (prevData, id, moveType) => {
  if (moveType === 'up') {
    prevData.forEach((element, nodeIndex) => {
      if (element.children) {
        sortInfo(element.children, id, moveType);
      }
      if (element.id === id) {
        if (nodeIndex > 0) {
          const temp = prevData[nodeIndex];
          prevData[nodeIndex] = prevData[nodeIndex - 1];
          prevData[nodeIndex - 1] = temp;
        }
      }
    });
  }
  if (moveType === 'down') {
    prevData.forEach((element, nodeIndex) => {
      if (element.children) {
        sortInfo(element.children, id, moveType);
      }
      if (element.id === id) {
        if (nodeIndex < prevData.length - 1) {
          const temp = prevData[nodeIndex];
          prevData[nodeIndex] = prevData[nodeIndex + 1];
          prevData[nodeIndex + 1] = temp;
        }
      }
    });
  }
  return prevData;
};

/**
 * 把树形数组的最后一层children的key值返回
 * @param treeData
 * @param keyName
 * @param isGetDisabled 只获取disabled状态的
 * @returns {[]}
 */
export function extractLastLevelIds(treeData, keyName, isGetDisabled = false) {
  const ids = [];
  function traverse(nodes) {
    for (const node of nodes) {
      if (isGetDisabled) {
        if (node.children && node.children.length > 0) {
          traverse(node.children);
        } else {
          if (node.disabled) {
            ids.push(node[keyName]);
          }
        }
      } else {
        if (node.children && node.children.length > 0) {
          traverse(node.children);
        } else {
          ids.push(node[keyName]);
        }
      }
    }
  }
  traverse(treeData);
  return ids;
}

/**
 * 对象数组去重（单层数组）
 * @param arr 需要处理的数组
 * @param key 基于什么去重
 * @returns {any[]}
 */
function removeDuplicates(arr, key) {
  const uniqueMap = new Map();
  for (const obj of arr) {
    const keyValue = obj[key];
    if (!uniqueMap.has(keyValue)) {
      uniqueMap.set(keyValue, obj);
    }
  }
  return Array.from(uniqueMap.values());
}
// 情景模板列表 配置树形参数value，title
export function insetTreeValueTitle(treeData, leafDisabled) {
  function traverseTree(data) {
    // 在每个项中添加 key 字段
    data.forEach((item) => {
      item.value = item.sceneId;
      item.title = item.sceneName;
      item.key = item.sceneId;
      if (item.children && item.children.length === 0) item.disabled = true;
      if (item.children && item.children.length > 0) {
        traverseTree(item.children); // 递归遍历子项
      }
    });
  }
  const newTreeData = cloneDeep(treeData);
  traverseTree(newTreeData);
  return newTreeData;
}
